// Code generated by MockGen. DO NOT EDIT.
// Source: mosn.io/api/trace.go

// Package mock is a generated GoMock package.
package mock

import (
	context "context"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	api "mosn.io/api"
)

// MockDriver is a mock of Driver interface.
type MockDriver struct {
	ctrl     *gomock.Controller
	recorder *MockDriverMockRecorder
}

// MockDriverMockRecorder is the mock recorder for MockDriver.
type MockDriverMockRecorder struct {
	mock *MockDriver
}

// NewMockDriver creates a new mock instance.
func NewMockDriver(ctrl *gomock.Controller) *MockDriver {
	mock := &MockDriver{ctrl: ctrl}
	mock.recorder = &MockDriverMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockDriver) EXPECT() *MockDriverMockRecorder {
	return m.recorder
}

// Get mocks base method.
func (m *MockDriver) Get(proto api.ProtocolName) api.Tracer {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", proto)
	ret0, _ := ret[0].(api.Tracer)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *MockDriverMockRecorder) Get(proto interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDriver)(nil).Get), proto)
}

// Init mocks base method.
func (m *MockDriver) Init(config map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", config)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockDriverMockRecorder) Init(config interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockDriver)(nil).Init), config)
}

// Register mocks base method.
func (m *MockDriver) Register(proto api.ProtocolName, builder api.TracerBuilder) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Register", proto, builder)
}

// Register indicates an expected call of Register.
func (mr *MockDriverMockRecorder) Register(proto, builder interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Register", reflect.TypeOf((*MockDriver)(nil).Register), proto, builder)
}

// MockTracer is a mock of Tracer interface.
type MockTracer struct {
	ctrl     *gomock.Controller
	recorder *MockTracerMockRecorder
}

// MockTracerMockRecorder is the mock recorder for MockTracer.
type MockTracerMockRecorder struct {
	mock *MockTracer
}

// NewMockTracer creates a new mock instance.
func NewMockTracer(ctrl *gomock.Controller) *MockTracer {
	mock := &MockTracer{ctrl: ctrl}
	mock.recorder = &MockTracerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockTracer) EXPECT() *MockTracerMockRecorder {
	return m.recorder
}

// Start mocks base method.
func (m *MockTracer) Start(ctx context.Context, request interface{}, startTime time.Time) api.Span {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Start", ctx, request, startTime)
	ret0, _ := ret[0].(api.Span)
	return ret0
}

// Start indicates an expected call of Start.
func (mr *MockTracerMockRecorder) Start(ctx, request, startTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Start", reflect.TypeOf((*MockTracer)(nil).Start), ctx, request, startTime)
}

// MockSpan is a mock of Span interface.
type MockSpan struct {
	ctrl     *gomock.Controller
	recorder *MockSpanMockRecorder
}

// MockSpanMockRecorder is the mock recorder for MockSpan.
type MockSpanMockRecorder struct {
	mock *MockSpan
}

// NewMockSpan creates a new mock instance.
func NewMockSpan(ctrl *gomock.Controller) *MockSpan {
	mock := &MockSpan{ctrl: ctrl}
	mock.recorder = &MockSpanMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSpan) EXPECT() *MockSpanMockRecorder {
	return m.recorder
}

// FinishSpan mocks base method.
func (m *MockSpan) FinishSpan() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "FinishSpan")
}

// FinishSpan indicates an expected call of FinishSpan.
func (mr *MockSpanMockRecorder) FinishSpan() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinishSpan", reflect.TypeOf((*MockSpan)(nil).FinishSpan))
}

// InjectContext mocks base method.
func (m *MockSpan) InjectContext(requestHeaders api.HeaderMap, requestInfo api.RequestInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InjectContext", requestHeaders, requestInfo)
}

// InjectContext indicates an expected call of InjectContext.
func (mr *MockSpanMockRecorder) InjectContext(requestHeaders, requestInfo interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InjectContext", reflect.TypeOf((*MockSpan)(nil).InjectContext), requestHeaders, requestInfo)
}

// ParentSpanId mocks base method.
func (m *MockSpan) ParentSpanId() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ParentSpanId")
	ret0, _ := ret[0].(string)
	return ret0
}

// ParentSpanId indicates an expected call of ParentSpanId.
func (mr *MockSpanMockRecorder) ParentSpanId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ParentSpanId", reflect.TypeOf((*MockSpan)(nil).ParentSpanId))
}

// SetOperation mocks base method.
func (m *MockSpan) SetOperation(operation string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOperation", operation)
}

// SetOperation indicates an expected call of SetOperation.
func (mr *MockSpanMockRecorder) SetOperation(operation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOperation", reflect.TypeOf((*MockSpan)(nil).SetOperation), operation)
}

// SetRequestInfo mocks base method.
func (m *MockSpan) SetRequestInfo(requestInfo api.RequestInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRequestInfo", requestInfo)
}

// SetRequestInfo indicates an expected call of SetRequestInfo.
func (mr *MockSpanMockRecorder) SetRequestInfo(requestInfo interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRequestInfo", reflect.TypeOf((*MockSpan)(nil).SetRequestInfo), requestInfo)
}

// SetTag mocks base method.
func (m *MockSpan) SetTag(key uint64, value string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTag", key, value)
}

// SetTag indicates an expected call of SetTag.
func (mr *MockSpanMockRecorder) SetTag(key, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTag", reflect.TypeOf((*MockSpan)(nil).SetTag), key, value)
}

// SpanId mocks base method.
func (m *MockSpan) SpanId() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpanId")
	ret0, _ := ret[0].(string)
	return ret0
}

// SpanId indicates an expected call of SpanId.
func (mr *MockSpanMockRecorder) SpanId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpanId", reflect.TypeOf((*MockSpan)(nil).SpanId))
}

// SpawnChild mocks base method.
func (m *MockSpan) SpawnChild(operationName string, startTime time.Time) api.Span {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpawnChild", operationName, startTime)
	ret0, _ := ret[0].(api.Span)
	return ret0
}

// SpawnChild indicates an expected call of SpawnChild.
func (mr *MockSpanMockRecorder) SpawnChild(operationName, startTime interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpawnChild", reflect.TypeOf((*MockSpan)(nil).SpawnChild), operationName, startTime)
}

// Tag mocks base method.
func (m *MockSpan) Tag(key uint64) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tag", key)
	ret0, _ := ret[0].(string)
	return ret0
}

// Tag indicates an expected call of Tag.
func (mr *MockSpanMockRecorder) Tag(key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tag", reflect.TypeOf((*MockSpan)(nil).Tag), key)
}

// TraceId mocks base method.
func (m *MockSpan) TraceId() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TraceId")
	ret0, _ := ret[0].(string)
	return ret0
}

// TraceId indicates an expected call of TraceId.
func (mr *MockSpanMockRecorder) TraceId() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TraceId", reflect.TypeOf((*MockSpan)(nil).TraceId))
}
